package cn.tedu.erp.project.service.impl;

import cn.tedu.erp.project.ex.ServiceException;
import cn.tedu.erp.project.mapper.RoleMapper;
import cn.tedu.erp.project.mapper.RolePermissionMapper;
import cn.tedu.erp.project.pojo.dto.RoleAddNewDTO;
import cn.tedu.erp.project.pojo.dto.RoleUpdateDTO;
import cn.tedu.erp.project.pojo.entity.Role;
import cn.tedu.erp.project.pojo.entity.RolePermission;
import cn.tedu.erp.project.pojo.vo.PermissionListVO;
import cn.tedu.erp.project.pojo.vo.RoleListVO;
import cn.tedu.erp.project.pojo.vo.RoleStandardVO;
import cn.tedu.erp.project.service.IRoleService;
import cn.tedu.erp.project.web.ServiceCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

@Slf4j
@Service
@Transactional
public class RoleServiceImpl implements IRoleService {
    @Autowired
    private RoleMapper roleMapper;
    @Autowired
    private RolePermissionMapper rolePermissionMapper;


    public RoleServiceImpl() {
        log.debug("创建业务类对象:RoleServiceImpl");
    }

    /**
     * 添加角色
     *
     * @param roleAddNewDTO
     */
    @Override
    public void addNew(RoleAddNewDTO roleAddNewDTO) {
        log.debug("开始处理添加角色的业务,参数为:{}", roleAddNewDTO);
        //通过参数得到权限id的数组
        Long[] permissionIds = roleAddNewDTO.getPermissionIds();
        for (Long permissionId : permissionIds) {
            if (permissionId == 1 || permissionId == 2
                    || permissionId == 3 || permissionId == 4) {
                //是:抛出异常
                String message = "添加失败,角色已存在!";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERROR_CONFLICT, message);
            }
        }
        //从参数对象中获取角色的名称
        String name = roleAddNewDTO.getName();
        //调用deptMapper的countbyname()执行统计
        int countName = roleMapper.countByName(name);
        //判断统计结果是否大于0
        if (countName > 0) {
            //是:抛出异常
            String message = "添加失败,添加的角色名称已存在!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT, message);
        }
        //创建对象
        Role role = new Role();
        //复制属性
        BeanUtils.copyProperties(roleAddNewDTO, role);
        // 调用deptMapper的insert方法
        int row = roleMapper.insert(role);
        if (row != 1) {
            String message = "添加角色失败,服务器忙,稍后再试";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_INSERT, message);
        }
        //为新添加的角色分配权限
        //基于角色id的数组创建roleMapper的批量插入角色的参数list<RolePermission>
        List<RolePermission> rolePermissionList = new ArrayList<>();
        for (Long permissionId : permissionIds) {
            RolePermission rolePermission = new RolePermission();//创建角色权限对象
            rolePermission.setRoleId(role.getId());//添加要绑定对应权限的角色id
            rolePermission.setPermissionId(permissionId);//添加权限id
            rolePermissionList.add(rolePermission);//将角色权限对象添加到数组中
        }
        //调用deptRoleMapper的insertBatch()执行插入
        row = rolePermissionMapper.insertBatch(rolePermissionList);
        if (row < 1) {
            String message = "添加角色失败,服务器忙,稍后再试";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_INSERT, message);
        }
    }

    /**
     * 根据id删除角色
     *
     * @param id
     */
    @Override
    public void deleteById(Long id) {
        log.debug("开始处理删除角色的业务,参数为id={}", id);
        if (id == 1) {
            String message = "删除失败,被删除的角色不存在!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        //查看被删除的对象是否有权限,有:不能删,报异常
        int row = roleMapper.countPermissionById(id);
        if (row > 0) {
            String message = "删除失败,角色还有权限在存在!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT, message);
        }
        //查询被删除的对象是否存在,否:报异常
        RoleStandardVO roleStandardById = roleMapper.getStandardById(id);
        if (roleStandardById == null) {
            String message = "删除失败,被删除的角色不存在!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        //调用roleMapper的delete方法
        row = roleMapper.deleteById(id);
        if (row != 1) {
            String message = "删除失败,服务器忙,稍后再试!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_DELETE, message);
        }
        //调用RolePermissionMapper的delete方法
        row = rolePermissionMapper.deleteById(id);
        if (row < 1) {
            String message = "删除失败,服务器忙,稍后再试!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_DELETE, message);
        }
    }

    /**
     * 根据id修改角色
     *
     * @param id
     */
    @Override
    public void updateById(Long id, RoleUpdateDTO roleUpdateDTO) {
        log.debug("开始处理修改角色的业务,参数为id={}", id);
        if (id == 1) {
            String message = "修改失败,被修改的角色不存在!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        //查询要修改的角色是否存在
        RoleStandardVO roleStandardVO = roleMapper.getStandardById(id);
        if (roleStandardVO == null) {
            String message = "修改失败,角色不存在";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        log.debug("根据id={}获取的角色名称是否存在,结果为{}", id, roleStandardVO.getName());
        //查询要修改的角色名称是否同名
        int count = roleMapper.countByNameAndNotId(id, roleUpdateDTO.getName());
        if (count > 0) {
            String message = "修改失败,角色名称已经被占用";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT, message);
        }
        Role role = new Role();
        //复制属性
        BeanUtils.copyProperties(roleUpdateDTO, role);
        //设置id
        role.setId(id);
        int rows = roleMapper.update(role);
        if (rows != 1) {
            String message = "修改角色失败,服务器忙,请稍后再试!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_UPDATE, message);
        }
    }

    /**
     * 根据id查询角色详情
     *
     * @param id
     * @return
     */
    @Override
    public RoleStandardVO getStandardById(Long id) {
        log.debug("开始处理查询角色详情的业务,参数为id={}", id);
        if (id == 1) {
            String message = "查询失败,被查询的角色不存在!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        //调用roleMapper的getStandardVO方法
        RoleStandardVO roleStandardVO = roleMapper.getStandardById(id);
        if (roleStandardVO == null) {
            String message = "查询失败,被查询的角色不存在!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        return roleStandardVO;
    }

    /**
     * 根据角色名称查询角色详情
     *
     * @param name
     * @return
     */
    @Override
    public RoleStandardVO getStandardByName(String name) {
        log.debug("开始处理查询角色详情的业务,参数为id={}", name);
        if (name.equals("系统管理员")) {
            String message = "查询失败,被查询的角色不存在!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        //调用roleMapper的getStandardVO方法
        RoleStandardVO roleStandardVO = roleMapper.getStandardByName(name);
        if (roleStandardVO == null) {
            String message = "查询失败,被查询的角色不存在!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        return roleStandardVO;
    }

    /**
     * 查询角色权限列表
     *
     * @param id
     * @return
     */
    @Override
    public List<PermissionListVO> listPermission(Long id) {
        log.debug("开始处理[查询角色权限列表]的业务,无参数");
        if (id == 1) {
            String message = "查询失败,被查询的角色不存在!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }

        List<PermissionListVO> permissionListVOList = roleMapper.listPermissionById(id);
        if (permissionListVOList.isEmpty()) {
            String message = "查询失败,被查询的角色没有包含权限!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        return permissionListVOList;
    }

    /**
     * 查询角色列表
     *
     * @return
     */
    @Override
    public List<RoleListVO> list() {
        log.debug("开始处理[查询角色列表]的业务,无参数");
        //调用roleMapper的list方法
        List<RoleListVO> list = roleMapper.list();
        //使用list的迭代器
        Iterator<RoleListVO> iterator = list.iterator();
        //查询为1的对象,直到将该对象从list集合中删除
        while (iterator.hasNext()) {
            RoleListVO item = iterator.next();
            if (item.getId() == 1) {
                iterator.remove();
                break;
            }
        }
        return list;
    }
}
